import * as cookie from "cookie";
import * as URL from "url";
import * as querystring from "querystring";

/**
 * given this: [ 'msg1=value1', 'msg2=value2' ]
 * output this: 'msg1=value1&msg2=value2'
 * @param dataArguments
 */
const joinDataArguments = dataArguments => {
  let data = "";
  dataArguments.forEach((argument, i) => {
    if (i === 0) {
      data += argument;
    } else {
      data += `&${argument}`;
    }
  });
  return data;
};

const parseCurlCommand = curlCommand => {
  let newlineFound = /\r|\n/.exec(curlCommand);
  if (newlineFound) {
    // remove newlines
    curlCommand = curlCommand.replace(/\r|\n/g, "");
  }
  // yargs parses -XPOST as separate arguments. just prescreen for it.
  curlCommand = curlCommand.replace(/ -XPOST/, " -X POST");
  curlCommand = curlCommand.replace(/ -XGET/, " -X GET");
  curlCommand = curlCommand.replace(/ -XPUT/, " -X PUT");
  curlCommand = curlCommand.replace(/ -XPATCH/, " -X PATCH");
  curlCommand = curlCommand.replace(/ -XDELETE/, " -X DELETE");
  curlCommand = curlCommand.trim();
  let parsedArguments = require("yargs-parser")(curlCommand);
  let cookieString;
  let cookies;
  let url = parsedArguments._[1];
  if (!url) {
    for (let argName in parsedArguments) {
      if (typeof parsedArguments[argName] === "string") {
        if (["http", "www."].includes(parsedArguments[argName])) {
          url = parsedArguments[argName];
        }
      }
    }
  }
  let headers;

  const parseHeaders = headerFieldName => {
    if (parsedArguments[headerFieldName]) {
      if (!headers) {
        headers = {};
      }
      if (!Array.isArray(parsedArguments[headerFieldName])) {
        parsedArguments[headerFieldName] = [parsedArguments[headerFieldName]];
      }
      parsedArguments[headerFieldName].forEach(header => {
        if (header.includes("Cookie")) {
          // stupid javascript tricks: closure
          cookieString = header;
        } else {
          let colonIndex = header.indexOf(":");
          let headerName = header.substring(0, colonIndex);
          let headerValue = header.substring(colonIndex + 1).trim();
          headers[headerName] = headerValue;
        }
      });
    }
  };

  parseHeaders("H");
  parseHeaders("header");
  if (parsedArguments.A) {
    if (!headers) {
      headers = [];
    }
    headers["User-Agent"] = parsedArguments.A;
  } else if (parsedArguments["user-agent"]) {
    if (!headers) {
      headers = [];
    }
    headers["User-Agent"] = parsedArguments["user-agent"];
  }

  if (parsedArguments.b) {
    cookieString = parsedArguments.b;
  }
  if (parsedArguments.cookie) {
    cookieString = parsedArguments.cookie;
  }
  let multipartUploads;
  if (parsedArguments.F) {
    multipartUploads = {};
    if (!Array.isArray(parsedArguments.F)) {
      parsedArguments.F = [parsedArguments.F];
    }
    parsedArguments.F.forEach(multipartArgument => {
      // input looks like key=value. value could be json or a file path prepended with an @
      const [key, value] = multipartArgument.split("=", 2);
      multipartUploads[key] = value;
    });
  }
  if (cookieString) {
    const cookieParseOptions = {
      decode: s => s
    };
    // separate out cookie headers into separate data structure
    // note: cookie is case insensitive
    cookies = cookie.parse(
      cookieString.replace(/^Cookie: /gi, ""),
      cookieParseOptions
    );
  }
  let method;
  if (parsedArguments.X === "POST") {
    method = "post";
  } else if (parsedArguments.X === "PUT" || parsedArguments["T"]) {
    method = "put";
  } else if (parsedArguments.X === "PATCH") {
    method = "patch";
  } else if (parsedArguments.X === "DELETE") {
    method = "delete";
  } else if (parsedArguments.X === "OPTIONS") {
    method = "options";
  } else if (
    (parsedArguments["d"] ||
      parsedArguments["data"] ||
      parsedArguments["data-ascii"] ||
      parsedArguments["data-binary"] ||
      parsedArguments["F"] ||
      parsedArguments["form"]) &&
    !(parsedArguments["G"] || parsedArguments["get"])
  ) {
    method = "post";
  } else if (parsedArguments["I"] || parsedArguments["head"]) {
    method = "head";
  } else {
    method = "get";
  }

  let compressed = !!parsedArguments.compressed;
  let urlObject = URL.parse(url); // eslint-disable-line

  // if GET request with data, convert data to query string
  // NB: the -G flag does not change the http verb. It just moves the data into the url.
  if (parsedArguments["G"] || parsedArguments["get"]) {
    urlObject.query = urlObject.query ? urlObject.query : "";
    let option =
      "d" in parsedArguments ? "d" : "data" in parsedArguments ? "data" : null;
    if (option) {
      let urlQueryString = "";

      if (!url.includes("?")) {
        url += "?";
      } else {
        urlQueryString += "&";
      }

      if (typeof parsedArguments[option] === "object") {
        urlQueryString += parsedArguments[option].join("&");
      } else {
        urlQueryString += parsedArguments[option];
      }
      urlObject.query += urlQueryString;
      url += urlQueryString;
      delete parsedArguments[option];
    }
  }
  let query = querystring.parse(urlObject.query, null, null, {
    maxKeys: 10000
  });

  urlObject.search = null; // Clean out the search/query portion.
  const request = {
    url,
    urlWithoutQuery: URL.format(urlObject)
  };
  if (compressed) {
    request["compressed"] = true;
  }

  if (Object.keys(query).length > 0) {
    request.query = query;
  }
  if (headers) {
    request.headers = headers;
  }
  request["method"] = method;

  if (cookies) {
    request.cookies = cookies;
    request.cookieString = cookieString.replace("Cookie: ", "");
  }
  if (multipartUploads) {
    request.multipartUploads = multipartUploads;
  }
  if (parsedArguments.data) {
    request.data = parsedArguments.data;
  } else if (parsedArguments["data-binary"]) {
    request.data = parsedArguments["data-binary"];
    request.isDataBinary = true;
  } else if (parsedArguments["d"]) {
    request.data = parsedArguments["d"];
  } else if (parsedArguments["data-ascii"]) {
    request.data = parsedArguments["data-ascii"];
  }

  if (parsedArguments["u"]) {
    request.auth = parsedArguments["u"];
  }
  if (parsedArguments["user"]) {
    request.auth = parsedArguments["user"];
  }
  if (Array.isArray(request.data)) {
    request.dataArray = request.data;
    request.data = joinDataArguments(request.data);
  }

  if (parsedArguments["k"] || parsedArguments["insecure"]) {
    request.insecure = true;
  }
  return request;
};

export default parseCurlCommand;
